from typing import List, Optional
import hashlib
from sqlalchemy.orm import Session
from app.models.user import User
from app.exception import ResourceNotFoundError, ValidationError
from app.utils.pagination import paginate

class UserService:
    """用户服务类"""
    
    @staticmethod
    def hash_password(password: str) -> str:
        """密码加密"""
        return hashlib.sha256(password.encode()).hexdigest()
        
    @staticmethod
    def verify_password(plain_password: str, hashed_password: str) -> bool:
        """验证密码
        
        Args:
            plain_password: 明文密码
            hashed_password: 哈希密码
            
        Returns:
            bool: 密码是否匹配
        """
        return UserService.hash_password(plain_password) == hashed_password
    
    @staticmethod
    def create_user(db: Session, username: str, email: str, password: str) -> User:
        """创建用户
        
        Args:
            db: 数据库会话
            username: 用户名
            email: 邮箱
            password: 密码
            
        Returns:
            User: 创建的用户对象
            
        Raises:
            ValidationError: 用户名或邮箱已存在
        """
        # 检查用户名和邮箱是否已存在
        if db.query(User).filter(User.username == username).first():
            raise ValidationError(f"用户名 {username} 已被使用")
        if db.query(User).filter(User.email == email).first():
            raise ValidationError(f"邮箱 {email} 已被使用")
        
        # 创建用户
        hashed_password = UserService.hash_password(password)
        user = User(username=username, email=email, password=hashed_password)
        db.add(user)
        db.commit()
        db.refresh(user)
        return user
    
    @staticmethod
    def get_user_by_id(db: Session, user_id: int) -> User:
        """通过ID获取用户
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            User: 用户对象
            
        Raises:
            ResourceNotFoundError: 用户不存在
        """
        user = db.query(User).filter(User.id == user_id).first()
        if not user:
            raise ResourceNotFoundError(f"ID为 {user_id} 的用户不存在")
        return user
    
    @staticmethod
    def get_user_by_username(db: Session, username: str) -> Optional[User]:
        """通过用户名获取用户
        
        Args:
            db: 数据库会话
            username: 用户名
            
        Returns:
            Optional[User]: 用户对象，不存在则返回None
        """
        return db.query(User).filter(User.username == username).first()
    
    @staticmethod
    def get_user_list(db: Session, page: int = 1, page_size: int = 10) -> dict:
        """获取用户列表（分页）
        
        Args:
            db: 数据库会话
            page: 页码
            page_size: 每页大小
            
        Returns:
            dict: 分页结果
        """
        users = db.query(User).all()
        return paginate(users, page, page_size)
    
    @staticmethod
    def update_user(db: Session, user_id: int, **kwargs) -> User:
        """更新用户信息
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            **kwargs: 要更新的字段
            
        Returns:
            User: 更新后的用户对象
            
        Raises:
            ResourceNotFoundError: 用户不存在
        """
        user = UserService.get_user_by_id(db, user_id)
        
        # 如果要更新密码，进行加密
        if 'password' in kwargs:
            kwargs['password'] = UserService.hash_password(kwargs['password'])
        
        # 更新用户信息
        for key, value in kwargs.items():
            if hasattr(user, key):
                setattr(user, key, value)
        
        db.commit()
        db.refresh(user)
        return user
    
    @staticmethod
    def delete_user(db: Session, user_id: int) -> bool:
        """删除用户
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            bool: 是否删除成功
            
        Raises:
            ResourceNotFoundError: 用户不存在
        """
        user = UserService.get_user_by_id(db, user_id)
        db.delete(user)
        db.commit()
        return True
